home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / ld / dist / patch2 / ld.diff3 < prev    next >
Encoding:
Text File  |  1990-10-26  |  61.9 KB  |  2,246 lines
  1. *** ld.original    Thu Oct 25 22:09:56 1990
  2. --- ld.current    Thu Oct 25 21:58:36 1990
  3. ***************
  4. *** 27,37 ****
  5. --- 27,170 ----
  6.   #include <fcntl.h>
  7.   #endif
  8.   
  9. + #define NO_C_PLUS_PLUS
  10. + 
  11. + #define TARGET_SUN2             2
  12. + #define TARGET_SUN3             3
  13. + #define TARGET_SUN4             4
  14. + #define TARGET_ALTOS            5
  15. + #define TARGET_I386             6   
  16. + #define TARGET_HPUX             7
  17. + #define TARGET_SONY_NEWS        8
  18. + #define TARGET_SEQUENT          9
  19. + #define TARGET_VAX              10
  20. + 
  21. + /*
  22. +  * If `TARGET_MACHINE' was not defined on the compiler command line,
  23. +  * then set it equal to the host machine.
  24. +  */
  25. + #ifndef TARGET_MACHINE
  26. + #if defined(sun) && defined(sparc)
  27. + #define TARGET_MACHINE  TARGET_SUN4
  28. + #endif
  29. + #if defined(sun) && (defined(m68020) || defined(mc68020))
  30. + #define TARGET_MACHINE  TARGET_SUN3
  31. + #endif
  32. + #if defined(sun) && (defined(m68010) || defined(mc68010))
  33. + #define TARGET_MACHINE  TARGET_SUN2
  34. + #endif
  35. + #if defined(ALTOS)
  36. + #define TARGET_MACHINE  TARGET_ALTOS
  37. + #endif
  38. + #if defined(hpux)
  39. + #define TARGET_MACHINE  TARGET_HPUX
  40. + #endif
  41. + #if defined(is386)
  42. + #define TARGET_MACHINE  TARGET_I386
  43. + #endif
  44. + #if defined(sony_news)
  45. + #define TARGET_MACHINE  TARGET_SONY_NEWS
  46. + #endif
  47. + #if defined(sequent)
  48. + #define TARGET_MACHINE  TARGET_SEQUENT
  49. + #endif
  50. + #if defined(is68k) && !defined(TARGET_MACHINE)
  51. + #define TARGET_MACHINE  TARGET_68K
  52. + #endif
  53. + #endif
  54. + 
  55. + #ifndef TARGET_MACHINE
  56. +     CANNOT COMPILE, NO TARGET MACHINE SPECIFIED
  57. + #endif
  58. + 
  59. + #ifndef BIG_ENDIAN
  60. + #define BIG_ENDIAN      4321
  61. + #endif
  62. + #ifndef LITTLE_ENDIAN
  63. + #define LITTLE_ENDIAN   1234
  64. + #endif
  65. + #ifndef PDP_ENDIAN
  66. + /* I think it is unlikely that anybody will try to cross compile
  67. +  * to or from a pdp, so only big-endian and little-endian are supported. */
  68. + #define PDP_ENDIAN   3412
  69. + #endif
  70. + 
  71. + #if TARGET_MACHINE==TARGET_SUN4         || \
  72. +     TARGET_MACHINE==TARGET_SUN3         || \
  73. +     TARGET_MACHINE==TARGET_SUN2         || \
  74. +     TARGET_MACHINE==TARGET_ALTOS        || \
  75. +     TARGET_MACHINE==TARGET_HPUX         || \
  76. +     TARGET_MACHINE==TARGET_SONY_NEWS    || \
  77. +     TARGET_MACHINE==TARGET_68K
  78. + #define TARGET_BYTE_ORDER       BIG_ENDIAN
  79. + #endif
  80. + 
  81. + #if TARGET_MACHINE==TARGET_VAX          || \
  82. +     TARGET_MACHINE==TARGET_I386         || \
  83. +     TARGET_MACHINE==TARGET_SEQUENT
  84. + #define TARGET_BYTE_ORDER       LITTLE_ENDIAN
  85. + #endif
  86. + 
  87. + #if TARGET_MACHINE==TARGET_SUN3
  88. + #define TARGET_PAGE_SIZE    0x2000
  89. + #endif
  90. + 
  91. + #if defined(sparc)      || \
  92. +     defined(m68000)     || \
  93. +     defined(mc68000)    || \
  94. +     defined(m68010)     || \
  95. +     defined(mc68010)    || \
  96. +     defined(m68020)     || \
  97. +     defined(mc68020)    || \
  98. +     defined(is68k)      || \
  99. +     defined(hpux)       || \
  100. +     defined(sony_news)
  101. + #define HOST_BYTE_ORDER     BIG_ENDIAN
  102. + #endif
  103. + 
  104. + #if defined(vax)        || \
  105. +     defined(is386)      || \
  106. +     defined(ds3100)     || \
  107. +     defined(sequent)
  108. + #define HOST_BYTE_ORDER     LITTLE_ENDIAN
  109. + #endif
  110. + 
  111. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  112. + static void fix_byte_order();
  113. + static void fix_exec_header_byte_order();
  114. + static void fix_symbol_byte_order();
  115. + static void target_to_host_reloc_byte_order();
  116. + static void host_to_target_reloc_byte_order();
  117. + static void fix_symbol_root_byte_order();
  118. + #endif
  119. + 
  120.   #ifdef COFF_ENCAPSULATE
  121.   #include "a.out.encap.h"
  122.   #else
  123. + #ifdef sprite
  124. + #if TARGET_MACHINE==TARGET_SUN4
  125. + #include <sun4.md/a.out.h>
  126. + #elif TARGET_MACHINE==TARGET_SUN3
  127. + #include <sun3.md/a.out.h>
  128. + #elif TARGET_MACHINE==TARGET_SEQUENT
  129. + #include <symm.md/a.out.h>
  130. + #else
  131. +     no a.out.h specified
  132. + #endif
  133. + #else
  134.   #include <a.out.h>
  135.   #endif
  136. + #endif
  137. + 
  138. + #ifdef sprite
  139. + #undef NEW_SEG_SIZE
  140. + #if TARGET_MACHINE==TARGET_SUN4
  141. + #define NEW_SEG_SIZE    0x40000
  142. + #endif
  143. + #if TARGET_MACHINE==TARGET_SUN3
  144. + #define NEW_SEG_SIZE    0x20000
  145. + #endif
  146. + #endif  /* sprite */
  147.   
  148.   #ifndef N_SET_MAGIC
  149.   #define N_SET_MAGIC(exec, val)  ((exec).a_magic = val)
  150. ***************
  151. *** 85,91 ****
  152.   
  153.   /* Define this to specify the default executable format.  */
  154.   
  155. ! #ifdef hpux
  156.   #define DEFAULT_MAGIC NMAGIC  /* hpux bugs screw ZMAGIC */
  157.   #endif
  158.   
  159. --- 218,224 ----
  160.   
  161.   /* Define this to specify the default executable format.  */
  162.   
  163. ! #if TARGET_MACHINE==TARGET_HPUX
  164.   #define DEFAULT_MAGIC NMAGIC  /* hpux bugs screw ZMAGIC */
  165.   #endif
  166.   
  167. ***************
  168. *** 96,125 ****
  169.   /* Ordinary 4.3bsd lacks these macros in a.out.h.  */
  170.   
  171.   #ifndef N_TXTADDR
  172. ! #if defined(vax) || defined(sony_news)
  173.   #define N_TXTADDR(X) 0
  174.   #endif
  175. ! #ifdef is68k
  176.   #define N_TXTADDR(x)  (sizeof (struct exec))
  177.   #endif
  178. ! #ifdef sequent
  179.   #define    N_TXTADDR(x) (N_ADDRADJ(x))
  180.   #endif
  181.   #endif
  182.   
  183.   #ifndef N_DATADDR
  184. ! #if defined(vax) || defined(sony_news)
  185.   #define N_DATADDR(x) \
  186.       (((x).a_magic==OMAGIC)? (N_TXTADDR(x)+(x).a_text) \
  187.       : (page_size+((N_TXTADDR(x)+(x).a_text-1) & ~(page_size-1))))
  188.   #endif
  189. ! #ifdef is68k
  190.   #define SEGMENT_SIZE 0x20000
  191.   #define N_DATADDR(x) \
  192. !     (((x).a_magic==Omagic)? (N_TXTADDR(x)+(x).a_text) \
  193.        : (SEGMENT_SIZE + ((N_TXTADDR(x)+(x).a_text-1) & ~(SEGMENT_SIZE-1))))
  194.   #endif
  195. ! #ifdef sequent
  196.   #define N_DATADDR(x) \
  197.       (((x).a_magic==OMAGIC)? (N_TXTADDR(x)+(x).a_text) \
  198.       : (page_size+(((x).a_text-1) & ~(page_size-1))))
  199. --- 229,258 ----
  200.   /* Ordinary 4.3bsd lacks these macros in a.out.h.  */
  201.   
  202.   #ifndef N_TXTADDR
  203. ! #if TARGET_MACHINE==TARGET_VAX || TARGET_MACHINE==TARGET_SONY_NEWS
  204.   #define N_TXTADDR(X) 0
  205.   #endif
  206. ! #if TARGET_MACHINE==TARGET_SUN3 || TARGET_MACHINE==TARGET_SUN2
  207.   #define N_TXTADDR(x)  (sizeof (struct exec))
  208.   #endif
  209. ! #if TARGET_MACHINE==TARGET_SEQUENT
  210.   #define    N_TXTADDR(x) (N_ADDRADJ(x))
  211.   #endif
  212.   #endif
  213.   
  214.   #ifndef N_DATADDR
  215. ! #if TARGET_MACHINE==TARGET_VAX || TARGET_MACHINE==TARGET_SONY_NEWS
  216.   #define N_DATADDR(x) \
  217.       (((x).a_magic==OMAGIC)? (N_TXTADDR(x)+(x).a_text) \
  218.       : (page_size+((N_TXTADDR(x)+(x).a_text-1) & ~(page_size-1))))
  219.   #endif
  220. ! #if TARGET_MACHINE==TARGET_SUN3 || TARGET_MACHINE==TARGET_SUN2
  221.   #define SEGMENT_SIZE 0x20000
  222.   #define N_DATADDR(x) \
  223. !     (((x).a_magic==OMAGIC)? (N_TXTADDR(x)+(x).a_text) \
  224.        : (SEGMENT_SIZE + ((N_TXTADDR(x)+(x).a_text-1) & ~(SEGMENT_SIZE-1))))
  225.   #endif
  226. ! #if TARGET_MACHINE==TARGET_SEQUENT
  227.   #define N_DATADDR(x) \
  228.       (((x).a_magic==OMAGIC)? (N_TXTADDR(x)+(x).a_text) \
  229.       : (page_size+(((x).a_text-1) & ~(page_size-1))))
  230. ***************
  231. *** 127,168 ****
  232.   #endif
  233.   
  234.   /* Define how to initialize system-dependent header fields.  */
  235. ! #ifdef sun
  236. ! #ifdef sparc
  237.   #define INITIALIZE_HEADER \
  238.     {outheader.a_machtype = M_SPARC; outheader.a_toolversion = 1;}
  239.   #endif
  240. ! #if defined(mc68010) || defined(m68010)
  241.   #define INITIALIZE_HEADER outheader.a_machtype = M_68010
  242.   #endif
  243. ! #ifndef INITIALIZE_HEADER
  244.   #define INITIALIZE_HEADER outheader.a_machtype = M_68020
  245.   #endif
  246. ! #endif
  247. ! #ifdef ALTOS
  248.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, M_68020)
  249.   #endif
  250. ! #ifdef is68k
  251. ! #ifdef M_68020
  252. ! /* ISI rel 4.0D doesn't use it, and rel 3.05 doesn't have an
  253. !    a_machtype field and so won't recognize the magic number.  To keep
  254. !    binary compatibility for now, just ignore it */
  255. ! #define INITIALIZE_HEADER outheader.a_machtype = 0;
  256. ! #endif
  257. ! #endif
  258. ! #ifdef hpux
  259.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, HP9000S200_ID)
  260.   #endif
  261. ! #if defined(i386) && !defined(sequent)
  262.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, M_386)
  263.   #endif
  264. ! 
  265. ! #ifdef is68k
  266.   /* This enables code to take care of an ugly hack in the ISI OS.
  267.      If a symbol beings with _$, then the object file is included only
  268.      if the rest of the symbol name has been referenced. */
  269.   #define DOLLAR_KLUDGE
  270.   #endif
  271.   
  272.   /*
  273.    * Alloca include.
  274. --- 260,312 ----
  275.   #endif
  276.   
  277.   /* Define how to initialize system-dependent header fields.  */
  278. ! #if TARGET_MACHINE==TARGET_SUN4
  279.   #define INITIALIZE_HEADER \
  280.     {outheader.a_machtype = M_SPARC; outheader.a_toolversion = 1;}
  281.   #endif
  282. ! #if TARGET_MACHINE==TARGET_SUN2
  283.   #define INITIALIZE_HEADER outheader.a_machtype = M_68010
  284.   #endif
  285. ! #if TARGET_MACHINE==TARGET_SUN3
  286.   #define INITIALIZE_HEADER outheader.a_machtype = M_68020
  287.   #endif
  288. ! #if TARGET_MACHINE==TARGET_ALTOS
  289.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, M_68020)
  290.   #endif
  291. ! #if TARGET_MACHINE==TARGET_HPUX
  292.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, HP9000S200_ID)
  293.   #endif
  294. ! #if TARGET_MACHINE==TARGET_I386
  295.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, M_386)
  296.   #endif
  297. ! #if TARGET_MACHINE==TARGET_68K
  298. ! #define INITIALIZE_HEADER outheader.a_machtype = 0;  
  299.   /* This enables code to take care of an ugly hack in the ISI OS.
  300.      If a symbol beings with _$, then the object file is included only
  301.      if the rest of the symbol name has been referenced. */
  302.   #define DOLLAR_KLUDGE
  303.   #endif
  304. + #if TARGET==TARGET_SEQUENT
  305. + /* This is all stuff needed to make standalone binaries */
  306. + static struct gdtbl gdt_filler = {
  307. +     { 0x0000FFFF, 0x00CF9A00 },    /* code entry */
  308. +     { 0x0000FFFF, 0x00CF9200 },    /* data entry */
  309. +     { 0x00180017, 0x00000000 },    /* 6 byte descriptor */
  310. + };
  311. + 
  312. + static char instr[] = {
  313. +     0x67, 0x66, 0x0f, 0x01, 0x15, 0x30, 0x00, 0x00, 0x00,
  314. +     0x0f, 0x20, 0xc3,
  315. +     0x80, 0xcb, 0x01,
  316. +     0x0f, 0x22, 0xc3,
  317. +     0xea, 0x5b, 0x00, 0x08, 0x00,
  318. +     0xbb, 0x10, 0x00, 0x00, 0x00,
  319. +     0x8e, 0xdb,
  320. +     0x8e, 0xd3,
  321. +     0x8e, 0xc3,
  322. +     0xff, 0x25, 0x6c, 0x00, 0x00, 0x00,
  323. +     0x00, 0x00, 0x00, 0x00, };
  324. + #endif   
  325.   
  326.   /*
  327.    * Alloca include.
  328. ***************
  329. *** 253,259 ****
  330.    *
  331.    */
  332.   
  333. ! #if defined(sun) && defined(sparc)
  334.   /* Sparc (Sun 4) macros */
  335.   #undef relocation_info
  336.   #define relocation_info                    reloc_info_sparc
  337. --- 397,403 ----
  338.    *
  339.    */
  340.   
  341. ! #if TARGET_MACHINE==TARGET_SUN4
  342.   /* Sparc (Sun 4) macros */
  343.   #undef relocation_info
  344.   #define relocation_info                    reloc_info_sparc
  345. ***************
  346. *** 264,275 ****
  347.   #define RELOC_MEMORY_SUB_P(r)        0
  348.   #define RELOC_MEMORY_ADD_P(r)           0
  349.   #define RELOC_ADD_EXTRA(r)              ((r)->r_addend)       
  350. ! #define RELOC_PCREL_P(r)             \
  351. !         ((r)->r_type >= RELOC_DISP8 && (r)->r_type <= RELOC_WDISP22)
  352. ! #define RELOC_VALUE_RIGHTSHIFT(r)       (reloc_target_rightshift[(r)->r_type])
  353. ! #define RELOC_TARGET_SIZE(r)            (reloc_target_size[(r)->r_type])
  354.   #define RELOC_TARGET_BITPOS(r)          0
  355. ! #define RELOC_TARGET_BITSIZE(r)         (reloc_target_bitsize[(r)->r_type])
  356.   
  357.   /* Note that these are very dependent on the order of the enums in
  358.      enum reloc_type (in a.out.h); if they change the following must be
  359. --- 408,422 ----
  360.   #define RELOC_MEMORY_SUB_P(r)        0
  361.   #define RELOC_MEMORY_ADD_P(r)           0
  362.   #define RELOC_ADD_EXTRA(r)              ((r)->r_addend)       
  363. ! #define RELOC_PCREL_P(r)                \
  364. !     ((int) (r)->r_type >= (int) RELOC_DISP8 && \
  365. !      (int) (r)->r_type <= (int) RELOC_WDISP22)
  366. ! #define RELOC_VALUE_RIGHTSHIFT(r) \
  367. !     (reloc_target_rightshift[(int) (r)->r_type])
  368. ! #define RELOC_TARGET_SIZE(r)            (reloc_target_size[(int) (r)->r_type])
  369.   #define RELOC_TARGET_BITPOS(r)          0
  370. ! #define RELOC_TARGET_BITSIZE(r) \
  371. !     (reloc_target_bitsize[(int) (r)->r_type])
  372.   
  373.   /* Note that these are very dependent on the order of the enums in
  374.      enum reloc_type (in a.out.h); if they change the following must be
  375. ***************
  376. *** 286,294 ****
  377.   };
  378.   
  379.   #define    MAX_ALIGNMENT    (sizeof (double))
  380.   #endif
  381.   
  382. ! #ifdef sequent
  383.   #define RELOC_ADDRESS(r)        ((r)->r_address)
  384.   #define RELOC_EXTERN_P(r)        ((r)->r_extern)
  385.   #define RELOC_TYPE(r)        ((r)->r_symbolnum)
  386. --- 433,445 ----
  387.   };
  388.   
  389.   #define    MAX_ALIGNMENT    (sizeof (double))
  390. +   /* The pagesize on an old sun4 is 0x2000, on sparcStation it is 0x1000.
  391. +      If you want to use the same binaries on both, then you need to use
  392. +      the larger pagesize. */
  393. + #define TARGET_PAGE_SIZE    0x2000
  394.   #endif
  395.   
  396. ! #if TARGET_MACHINE==TARGET_SEQUENT
  397.   #define RELOC_ADDRESS(r)        ((r)->r_address)
  398.   #define RELOC_EXTERN_P(r)        ((r)->r_extern)
  399.   #define RELOC_TYPE(r)        ((r)->r_symbolnum)
  400. ***************
  401. *** 301,306 ****
  402. --- 452,458 ----
  403.   #define RELOC_TARGET_SIZE(r)        ((r)->r_length)
  404.   #define RELOC_TARGET_BITPOS(r)    0
  405.   #define RELOC_TARGET_BITSIZE(r)    32
  406. + #define TARGET_PAGE_SIZE    0x1000
  407.   #endif
  408.   
  409.   /* Default macros */
  410. ***************
  411. *** 530,535 ****
  412. --- 682,696 ----
  413.       }
  414.     symbol;
  415.   
  416. + #ifndef NO_C_PLUS_PLUS
  417. + /* Demangler for C++. */
  418. + extern char *cplus_demangle ();
  419. + #endif /* NO_C_PLUS_PLUS */
  420. + 
  421. + /* Demangler function to use. */
  422. + char *(*demangler)() = NULL;
  423. + 
  424. + 
  425.   /* Number of buckets in symbol hash table */
  426.   #define    TABSIZE    1009
  427.   
  428. ***************
  429. *** 804,809 ****
  430. --- 965,976 ----
  431.      and reduce the size of the bss section to match.  */
  432.   int specified_data_size;
  433.   
  434. + /* Gap to insert between end of bss and start of data seg */
  435. + int data_gap;
  436. + 
  437. + /* Nonzero if -Z was specified (for data_gap) */
  438. + int Z_flag_specified;
  439. + 
  440.   /* Magic number to use for the output file, set by switch.  */
  441.   int magic;
  442.   
  443. ***************
  444. *** 896,912 ****
  445.   char *concat ();
  446.   char *get_file_name ();
  447.   symbol *getsym (), *getsym_soft ();
  448. ! 
  449.   int
  450.   main (argc, argv)
  451.        char **argv;
  452.        int argc;
  453.   {
  454.     page_size = getpagesize ();
  455.     progname = argv[0];
  456.   
  457.     /* Clear the cumulative info on the output file.  */
  458. - 
  459.     text_size = 0;
  460.     data_size = 0;
  461.     bss_size = 0;
  462. --- 1063,1096 ----
  463.   char *concat ();
  464.   char *get_file_name ();
  465.   symbol *getsym (), *getsym_soft ();
  466. ! 
  467.   int
  468.   main (argc, argv)
  469.        char **argv;
  470.        int argc;
  471.   {
  472. + /*   Added this to stop ld core-dumping on very large .o files.    */
  473. + #ifdef RLIMIT_STACK
  474. +   /* Get rid of any avoidable limit on stack size.  */
  475. +   {
  476. +       struct rlimit rlim;
  477. + 
  478. +       /* Set the stack limit huge so that alloca does not fail. */
  479. +       getrlimit (RLIMIT_STACK, &rlim);
  480. +       rlim.rlim_cur = rlim.rlim_max;
  481. +       setrlimit (RLIMIT_STACK, &rlim);
  482. +   }
  483. + #endif /* RLIMIT_STACK */
  484. + 
  485. + #ifdef TARGET_PAGE_SIZE
  486. +   page_size = TARGET_PAGE_SIZE;
  487. + #else
  488.     page_size = getpagesize ();
  489. + #endif
  490. + 
  491.     progname = argv[0];
  492.   
  493.     /* Clear the cumulative info on the output file.  */
  494.     text_size = 0;
  495.     data_size = 0;
  496.     bss_size = 0;
  497. ***************
  498. *** 932,937 ****
  499. --- 1116,1122 ----
  500.     make_executable = 1;
  501.     force_executable = 0;
  502.     set_element_prefixes = 0;
  503. +   Z_flag_specified = 0;
  504.   
  505.     /* Initialize the cumulative counts of symbols.  */
  506.   
  507. ***************
  508. *** 948,955 ****
  509.   
  510.     /* Keep a list of symbols referenced from the command line */
  511.     cl_refs_allocated = 10;
  512. !   cmdline_references
  513. !     = (struct glosym **) xmalloc (cl_refs_allocated
  514.                     * sizeof(struct glosym *));
  515.     *cmdline_references = 0;
  516.   
  517. --- 1133,1140 ----
  518.   
  519.     /* Keep a list of symbols referenced from the command line */
  520.     cl_refs_allocated = 10;
  521. !   cmdline_references =
  522. !     (struct glosym **) xmalloc (cl_refs_allocated
  523.                     * sizeof(struct glosym *));
  524.     *cmdline_references = 0;
  525.   
  526. ***************
  527. *** 984,989 ****
  528. --- 1169,1177 ----
  529.   
  530.     text_size -= N_TXTOFF (outheader);
  531.   
  532. +   if (T_flag_specified)
  533. +       text_size = 0;    /* don't add sizeof(exec) at -T location */
  534. + 
  535.     if (text_size < 0)
  536.       text_size = 0;
  537.     entry_offset = text_size;
  538. ***************
  539. *** 1046,1051 ****
  540. --- 1234,1240 ----
  541.       case 'u':
  542.       case 'V':
  543.       case 'y':
  544. +     case 'Z':
  545.         if (arg[2])
  546.       return 1;
  547.         return 2;
  548. ***************
  549. *** 1062,1067 ****
  550. --- 1251,1265 ----
  551.         if (! strcmp (&arg[2], "data"))
  552.       return 2;
  553.         return 1;
  554. + 
  555. + #if TARGET==TARGET_SEQUENT      
  556. +       /* k == Symmetry standalone,
  557. +        * p == don't align text/data boundary (for 8K disk bootstraps).
  558. +        */
  559. +    case 'k':
  560. +    case 'p':
  561. +        return 1;
  562. + #endif       
  563.       }
  564.   
  565.     return 1;
  566. ***************
  567. *** 1158,1170 ****
  568.   
  569.     /* Now check some option settings for consistency.  */
  570.   
  571.   #ifdef NMAGIC
  572.     if ((magic == ZMAGIC || magic == NMAGIC)
  573.   #else
  574. !   if ((magic == ZMAGIC)
  575.   #endif
  576.         && (text_start - text_start_alignment) & (page_size - 1))
  577.       fatal ("-T argument not multiple of page size, with sharable output", 0);
  578.   
  579.     /* Append the standard search directories to the user-specified ones.  */
  580.     {
  581. --- 1356,1374 ----
  582.   
  583.     /* Now check some option settings for consistency.  */
  584.   
  585. + #ifndef sprite
  586.   #ifdef NMAGIC
  587.     if ((magic == ZMAGIC || magic == NMAGIC)
  588.   #else
  589. ! #ifdef SMAGIC
  590. !     if ((magic == SMAGIC || magic == ZMAGIC)
  591. ! #else
  592. !     if ((magic == ZMAGIC)
  593. ! #endif /* SMAGIC */
  594.   #endif
  595.         && (text_start - text_start_alignment) & (page_size - 1))
  596.       fatal ("-T argument not multiple of page size, with sharable output", 0);
  597. + #endif
  598.   
  599.     /* Append the standard search directories to the user-specified ones.  */
  600.     {
  601. ***************
  602. *** 1240,1245 ****
  603. --- 1444,1452 ----
  604.       return;
  605.     if (! strcmp (swt + 1, "Ttext"))
  606.       {
  607. + #ifdef sprite 
  608. +       magic = OMAGIC;
  609. + #endif
  610.         text_start = parse (arg, "%x", "invalid argument to -Ttext");
  611.         T_flag_specified = 1;
  612.         return;
  613. ***************
  614. *** 1280,1286 ****
  615. --- 1487,1508 ----
  616.         add_cmdline_ref (entry_symbol);
  617.         return;
  618.   
  619. + #if TARGET==TARGET_SEQUENT
  620. +     case 'k':
  621. + #ifdef SMAGIC
  622. +       magic = SMAGIC;
  623. + #else
  624. +       fatal("No SMAGIC defined for -k");
  625. + #endif
  626. +       return;
  627. + #endif
  628. + 
  629.       case 'l':
  630. + #ifndef NO_C_PLUS_PLUS
  631. +       /* If linking with libg++, use the C++ demangler. */
  632. +       if (arg != NULL && strcmp (arg, "g++") == 0)
  633. +       demangler = cplus_demangle;
  634. + #endif /* NO_C_PLUS_PLUS */
  635.         return;
  636.   
  637.       case 'L':
  638. ***************
  639. *** 1323,1328 ****
  640. --- 1545,1553 ----
  641.         return;
  642.   
  643.       case 'T':
  644. + #ifdef sprite
  645. +       magic = OMAGIC;
  646. + #endif      
  647.         text_start = parse (arg, "%x", "invalid argument to -T");
  648.         T_flag_specified = 1;
  649.         return;
  650. ***************
  651. *** 1372,1377 ****
  652. --- 1597,1609 ----
  653.         magic = ZMAGIC;
  654.         return;
  655.   
  656. +     case 'Z':
  657. +       data_gap = parse (arg, "%x", "invalid argument to -Z");
  658. +       if (data_gap % page_size)
  659. +       fatal("-Z argument not a multiple of page size", 0);
  660. +       Z_flag_specified = 1;
  661. +       return;
  662. + 
  663.       default:
  664.         fatal ("invalid command option `%s'", swt);
  665.       }
  666. ***************
  667. *** 1415,1421 ****
  668.   
  669.      FUNCTION receives two arguments: the entry, and ARG.  It must be a
  670.      function returning unsigned long (though this can probably be fudged). */
  671. ! 
  672.   unsigned long
  673.   check_each_file (function, arg)
  674.        register unsigned long (*function)();
  675. --- 1647,1653 ----
  676.   
  677.      FUNCTION receives two arguments: the entry, and ARG.  It must be a
  678.      function returning unsigned long (though this can probably be fudged). */
  679. ! #if 0
  680.   unsigned long
  681.   check_each_file (function, arg)
  682.        register unsigned long (*function)();
  683. ***************
  684. *** 1440,1445 ****
  685. --- 1672,1678 ----
  686.       }
  687.     return 0;
  688.   }
  689. + #endif
  690.   
  691.   /* Like `each_file' but ignore files that were just for symbol definitions.  */
  692.   
  693. ***************
  694. *** 1496,1502 ****
  695.   
  696.     if (entry->search_dirs_flag)
  697.       {
  698. -       register char **p = search_dirs;
  699.         int i;
  700.   
  701.         for (i = 0; i < n_search_dirs; i++)
  702. --- 1729,1734 ----
  703. ***************
  704. *** 1596,1601 ****
  705. --- 1828,1836 ----
  706.     len = read (desc, loc, sizeof (struct exec));
  707.     if (len != sizeof (struct exec))
  708.       fatal_with_file ("failure reading header of ", entry);
  709. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  710. +   fix_exec_header_byte_order(loc);
  711. + #endif
  712.     if (N_BADMAG (*loc))
  713.       fatal_with_file ("bad magic number in ", entry);
  714.   
  715. ***************
  716. *** 1622,1632 ****
  717.     lseek (desc, N_SYMOFF (entry->header) + entry->starting_offset, 0);
  718.     if (entry->header.a_syms != read (desc, entry->symbols, entry->header.a_syms))
  719.       fatal_with_file ("premature end of file in symbols of ", entry);
  720. ! 
  721.     lseek (desc, N_STROFF (entry->header) + entry->starting_offset, 0);
  722.     if (sizeof str_size != read (desc, &str_size, sizeof str_size))
  723.       fatal_with_file ("bad string table size in ", entry);
  724. ! 
  725.     entry->string_size = str_size;
  726.   }
  727.   
  728. --- 1857,1871 ----
  729.     lseek (desc, N_SYMOFF (entry->header) + entry->starting_offset, 0);
  730.     if (entry->header.a_syms != read (desc, entry->symbols, entry->header.a_syms))
  731.       fatal_with_file ("premature end of file in symbols of ", entry);
  732. ! #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  733. !   fix_symbol_byte_order(entry->symbols, entry->header.a_syms);
  734. ! #endif
  735.     lseek (desc, N_STROFF (entry->header) + entry->starting_offset, 0);
  736.     if (sizeof str_size != read (desc, &str_size, sizeof str_size))
  737.       fatal_with_file ("bad string table size in ", entry);
  738. ! #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  739. !   fix_byte_order(&str_size, sizeof(str_size));
  740. ! #endif
  741.     entry->string_size = str_size;
  742.   }
  743.   
  744. ***************
  745. *** 1706,1712 ****
  746.     len = read (desc, &hdr, sizeof hdr);
  747.     if (len != sizeof hdr)
  748.       fatal_with_file ("failure reading header of ", entry);
  749. ! 
  750.     if (!N_BADMAG (hdr))
  751.       {
  752.         read_entry_symbols (desc, entry);
  753. --- 1945,1953 ----
  754.     len = read (desc, &hdr, sizeof hdr);
  755.     if (len != sizeof hdr)
  756.       fatal_with_file ("failure reading header of ", entry);
  757. ! #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  758. !   fix_exec_header_byte_order(&hdr);
  759. ! #endif
  760.     if (!N_BADMAG (hdr))
  761.       {
  762.         read_entry_symbols (desc, entry);
  763. ***************
  764. *** 1738,1744 ****
  765.     register struct nlist
  766.       *p,
  767.       *end = entry->symbols + entry->header.a_syms / sizeof (struct nlist);
  768. -   int lowest_set_vector = -1;
  769.   
  770.     if (trace_files) prline_file_name (entry, stderr);
  771.   
  772. --- 1979,1984 ----
  773. ***************
  774. *** 1748,1754 ****
  775.         if (set_element_prefixes
  776.         && set_element_prefixed_p (p->n_un.n_strx + entry->strings))
  777.       p->n_type += (N_SETA - N_ABS);
  778. - 
  779.         if (SET_ELEMENT_P (p->n_type))
  780.       {
  781.         set_symbol_count++;
  782. --- 1988,1993 ----
  783. ***************
  784. *** 1808,1814 ****
  785.      all such structs that refer to the same global symbol.
  786.      This chain starts in the `refs' field of the symbol table entry
  787.      and is chained through the `n_name'.  */
  788. - 
  789.   void
  790.   enter_global_ref (nlist_p, name, entry)
  791.        register struct nlist *nlist_p;
  792. --- 2047,2052 ----
  793. ***************
  794. *** 1861,1868 ****
  795.       {
  796.         /* Indirect symbols value should be modified to point
  797.            a symbol being equivalenced to. */
  798. !       nlist_p->n_value
  799. !         = (unsigned int) getsym ((nlist_p + 1)->n_un.n_strx
  800.                        + entry->strings);
  801.         if ((symbol *) nlist_p->n_value == sp)
  802.           {
  803. --- 2099,2106 ----
  804.       {
  805.         /* Indirect symbols value should be modified to point
  806.            a symbol being equivalenced to. */
  807. !       nlist_p->n_value =
  808. !         (unsigned int) getsym ((nlist_p + 1)->n_un.n_strx
  809.                        + entry->strings);
  810.         if ((symbol *) nlist_p->n_value == sp)
  811.           {
  812. ***************
  813. *** 1961,1967 ****
  814.              (nlist_p + 1)->n_un.n_strx + entry->strings);
  815.         break;
  816.   
  817. ! #ifdef sequent
  818.       case N_SHUNDF:
  819.         reftype = "shared undf";
  820.         break;
  821. --- 2199,2205 ----
  822.              (nlist_p + 1)->n_un.n_strx + entry->strings);
  823.         break;
  824.   
  825. ! #if TARGET_MACHINE==TARGET_SEQUENT
  826.       case N_SHUNDF:
  827.         reftype = "shared undf";
  828.         break;
  829. ***************
  830. *** 1991,1996 ****
  831. --- 2229,2235 ----
  832.      contain the nlist point entry, and it returns the files entry
  833.      pointer (cast to unsigned long) if it does. */
  834.   
  835. + #if 0
  836.   unsigned long
  837.   contains_symbol (entry, n_ptr)
  838.        struct file_entry *entry;
  839. ***************
  840. *** 2002,2007 ****
  841. --- 2241,2247 ----
  842.       return (unsigned long) entry;
  843.     return 0;
  844.   }
  845. + #endif
  846.   
  847.   
  848.   /* Searching libraries */
  849. ***************
  850. *** 2130,2136 ****
  851.     bytes_read = read (desc, symdef_data, member_length);
  852.     if (bytes_read != member_length)
  853.       fatal_with_file ("malformatted __.SYMDEF in ", entry);
  854. ! 
  855.     number_of_symdefs = *symdef_data / sizeof (struct symdef);
  856.     if (number_of_symdefs < 0 ||
  857.          number_of_symdefs * sizeof (struct symdef) + 2 * sizeof (int) > member_length)
  858. --- 2370,2378 ----
  859.     bytes_read = read (desc, symdef_data, member_length);
  860.     if (bytes_read != member_length)
  861.       fatal_with_file ("malformatted __.SYMDEF in ", entry);
  862. ! #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  863. !   fix_byte_order(symdef_data, sizeof(*symdef_data));
  864. ! #endif
  865.     number_of_symdefs = *symdef_data / sizeof (struct symdef);
  866.     if (number_of_symdefs < 0 ||
  867.          number_of_symdefs * sizeof (struct symdef) + 2 * sizeof (int) > member_length)
  868. ***************
  869. *** 2137,2142 ****
  870. --- 2379,2392 ----
  871.       fatal_with_file ("malformatted __.SYMDEF in ", entry);
  872.   
  873.     symdef_base = (struct symdef *) (symdef_data + 1);
  874. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  875. +   for (i = 0; i < number_of_symdefs; ++i)
  876. +     {
  877. +       fix_byte_order(&symdef_base[i].symbol_name_string_index, sizeof(int));
  878. +       fix_byte_order(&symdef_base[i].library_member_offset, sizeof(int));
  879. +     }
  880. +   fix_byte_order(symdef_base + number_of_symdefs, sizeof(int));
  881. + #endif
  882.     length_of_strings = *(int *) (symdef_base + number_of_symdefs);
  883.   
  884.     if (length_of_strings < 0
  885. ***************
  886. *** 2182,2188 ****
  887.              about the archive member that the symbol is in.  */
  888.   
  889.           if (sp && ((sp->referenced && !sp->defined)
  890. !                || (sp->defined && sp->max_common_size)))
  891.             {
  892.           int junk;
  893.           register int j;
  894. --- 2432,2441 ----
  895.              about the archive member that the symbol is in.  */
  896.   
  897.           if (sp && ((sp->referenced && !sp->defined)
  898. ! #if 1        
  899. !                || (sp->defined && sp->max_common_size))
  900. ! #endif
  901. !                )
  902.             {
  903.           int junk;
  904.           register int j;
  905. ***************
  906. *** 2312,2318 ****
  907.   /* ENTRY is an entry for a library member.
  908.      Its symbols have been read into core, but not entered.
  909.      Return nonzero if we ought to load this member.  */
  910. - 
  911.   int
  912.   subfile_wanted_p (entry)
  913.        struct file_entry *entry;
  914. --- 2565,2570 ----
  915. ***************
  916. *** 2333,2339 ****
  917.        potentially want it.  */
  918.         if (type & N_EXT
  919.         && (type != (N_UNDF | N_EXT) || p->n_value
  920. !           
  921.   #ifdef DOLLAR_KLUDGE
  922.              || name[1] == '$'
  923.   #endif
  924. --- 2585,2591 ----
  925.        potentially want it.  */
  926.         if (type & N_EXT
  927.         && (type != (N_UNDF | N_EXT) || p->n_value
  928. ! 
  929.   #ifdef DOLLAR_KLUDGE
  930.              || name[1] == '$'
  931.   #endif
  932. ***************
  933. *** 2378,2389 ****
  934.           {
  935.             /* Symbol being defined as common.
  936.                Remember this, but don't load subfile just for this.  */
  937. - 
  938.             /* If it didn't used to be common, up the count of
  939.                common symbols.  */
  940.             if (!sp->max_common_size)
  941.               common_defined_global_count++;
  942. - 
  943.             if (sp->max_common_size < p->n_value)
  944.               sp->max_common_size = p->n_value;
  945.             if (!sp->defined)
  946. --- 2630,2639 ----
  947. ***************
  948. *** 2392,2397 ****
  949. --- 2642,2674 ----
  950.             continue;
  951.           }
  952.   
  953. + #if TARGET==TARGET_SEQUENT
  954. +         /* Don't resolve common (data) symbols with text symbols*/
  955. +           if (type == (N_EXT | N_TEXT)) {
  956. +         int dontresolve = 0;
  957. +         struct nlist *p, *next;
  958. + 
  959. +         for (p = sp->refs; p; p = next) {
  960. +           if (p->n_value && (p->n_type == (N_UNDF | N_EXT))) {
  961. +               if (trace_files)
  962. +                   fprintf(stdout,
  963. +                       "refs check fail: symbol %s, ref type= 0x%x, ref value= 0x%x, sym type = 0x%x\n",
  964. +                       sp->name, p->n_type, p->n_value, type);
  965. +             dontresolve = 1;
  966. +             break;
  967. +           }
  968. +           next = (struct nlist *) p->n_un.n_name;
  969. +         }
  970. +         if (sp->trace) {
  971. +           fprintf(stdout, 
  972. +             "symbol %s can't use text sym def in file ", sp->name);
  973. +           print_file_name(entry, stdout);
  974. +           fprintf(stdout, "\n");
  975. +         }
  976. +         if (dontresolve)
  977. +           continue;
  978. +           }
  979. + #endif        
  980.             if (write_map)
  981.           {
  982.             print_file_name (entry, stdout);
  983. ***************
  984. *** 2418,2424 ****
  985.   digest_symbols ()
  986.   {
  987.     register int i;
  988. !   int setv_fill_count;
  989.   
  990.     if (trace_files)
  991.       fprintf (stderr, "Digesting symbol information:\n\n");
  992. --- 2695,2701 ----
  993.   digest_symbols ()
  994.   {
  995.     register int i;
  996. !   int setv_fill_count = 0;
  997.   
  998.     if (trace_files)
  999.       fprintf (stderr, "Digesting symbol information:\n\n");
  1000. ***************
  1001. *** 2432,2440 ****
  1002.   
  1003.   #ifdef NMAGIC
  1004.     if (magic == ZMAGIC || magic == NMAGIC)
  1005. ! #else
  1006.     if (magic == ZMAGIC)
  1007. ! #endif
  1008.       {
  1009.         int text_end = text_size + N_TXTOFF (outheader);
  1010.         text_pad = ((text_end + page_size - 1) & (- page_size)) - text_end;
  1011. --- 2709,2721 ----
  1012.   
  1013.   #ifdef NMAGIC
  1014.     if (magic == ZMAGIC || magic == NMAGIC)
  1015. ! #else /* NMAGIC */
  1016. ! #ifdef SMAGIC
  1017. !   if (magic == ZMAGIC || magic == SMAGIC)
  1018. ! #else /* SMAGIC */
  1019.     if (magic == ZMAGIC)
  1020. ! #endif /* SMAGIC */
  1021. ! #endif /* NMAGIC */
  1022.       {
  1023.         int text_end = text_size + N_TXTOFF (outheader);
  1024.         text_pad = ((text_end + page_size - 1) & (- page_size)) - text_end;
  1025. ***************
  1026. *** 2442,2448 ****
  1027.       }
  1028.   
  1029.     outheader.a_text = text_size;
  1030. ! #ifdef sequent
  1031.     outheader.a_text += N_ADDRADJ (outheader);
  1032.   #endif
  1033.   
  1034. --- 2723,2729 ----
  1035.       }
  1036.   
  1037.     outheader.a_text = text_size;
  1038. ! #if TARGET_MACHINE==TARGET_SEQUENT
  1039.     outheader.a_text += N_ADDRADJ (outheader);
  1040.   #endif
  1041.   
  1042. ***************
  1043. *** 2450,2459 ****
  1044.   
  1045.     if (! Tdata_flag_specified)
  1046.       data_start = N_DATADDR (outheader) + text_start - N_TXTADDR (outheader);
  1047. ! 
  1048.     /* Make sure bss starts out aligned as much as anyone can want.  */
  1049.   
  1050.     data_size = (data_size + sizeof(double) - 1) & ~(sizeof(double)-1);
  1051.   
  1052.     /* Set up the set element vector */
  1053.   
  1054. --- 2731,2744 ----
  1055.   
  1056.     if (! Tdata_flag_specified)
  1057.       data_start = N_DATADDR (outheader) + text_start - N_TXTADDR (outheader);
  1058. ! #ifdef foobar
  1059.     /* Make sure bss starts out aligned as much as anyone can want.  */
  1060.   
  1061.     data_size = (data_size + sizeof(double) - 1) & ~(sizeof(double)-1);
  1062. + #endif
  1063. + 
  1064. +   if (Z_flag_specified)
  1065. +       data_start += data_gap;
  1066.   
  1067.     /* Set up the set element vector */
  1068.   
  1069. ***************
  1070. *** 2463,2474 ****
  1071.            for each symbol for the length word at the beginning of the
  1072.        vector, plus a word for each symbol for a zero at the end of
  1073.        the vector (for incremental linking).  */
  1074. !       set_sect_size
  1075. !     = (2 * set_symbol_count + set_vector_count) * sizeof (unsigned long);
  1076.         set_sect_start = data_start + data_size;
  1077.         data_size += set_sect_size;
  1078.         set_vectors = (unsigned long *) xmalloc (set_sect_size);
  1079.         setv_fill_count = 0;
  1080.       }
  1081.   
  1082.     /* Compute start addresses of each file's sections and symbols.  */
  1083. --- 2748,2761 ----
  1084.            for each symbol for the length word at the beginning of the
  1085.        vector, plus a word for each symbol for a zero at the end of
  1086.        the vector (for incremental linking).  */
  1087. !       set_sect_size =
  1088. !         (2 * set_symbol_count + set_vector_count) * sizeof (unsigned long);
  1089.         set_sect_start = data_start + data_size;
  1090.         data_size += set_sect_size;
  1091.         set_vectors = (unsigned long *) xmalloc (set_sect_size);
  1092. + #if 1
  1093.         setv_fill_count = 0;
  1094. + #endif      
  1095.       }
  1096.   
  1097.     /* Compute start addresses of each file's sections and symbols.  */
  1098. ***************
  1099. *** 2493,2499 ****
  1100.       {
  1101.         /* For each symbol */
  1102.         register struct nlist *p, *next;
  1103. !       int defs = 0, com = sp->max_common_size, erred = 0;
  1104.         struct nlist *first_definition;
  1105.         for (p = sp->refs; p; p = next)
  1106.           {
  1107. --- 2780,2786 ----
  1108.       {
  1109.         /* For each symbol */
  1110.         register struct nlist *p, *next;
  1111. !       int defs = 0, com = sp->max_common_size;
  1112.         struct nlist *first_definition;
  1113.         for (p = sp->refs; p; p = next)
  1114.           {
  1115. ***************
  1116. *** 2575,2587 ****
  1117.            Reverse the vector itself to put it in file order.  */
  1118.         if ((sp->defined & ~N_EXT) == N_SETV)
  1119.           {
  1120. !           unsigned long length_word_index
  1121. !         = (sp->value - set_sect_start) / sizeof (unsigned long);
  1122.             unsigned long i, tmp;
  1123.   
  1124. !           set_vectors[length_word_index]
  1125. !         = setv_fill_count - 1 - length_word_index;
  1126. ! 
  1127.             /* Reverse the vector.  */
  1128.             for (i = 1;
  1129.              i < (setv_fill_count - length_word_index - 1) / 2 + 1;
  1130. --- 2862,2873 ----
  1131.            Reverse the vector itself to put it in file order.  */
  1132.         if ((sp->defined & ~N_EXT) == N_SETV)
  1133.           {
  1134. !           unsigned long length_word_index =
  1135. !             (sp->value - set_sect_start) / sizeof (unsigned long);
  1136.             unsigned long i, tmp;
  1137.   
  1138. !           set_vectors[length_word_index] =
  1139. !             setv_fill_count - 1 - length_word_index;
  1140.             /* Reverse the vector.  */
  1141.             for (i = 1;
  1142.              i < (setv_fill_count - length_word_index - 1) / 2 + 1;
  1143. ***************
  1144. *** 2588,2595 ****
  1145.              i++)
  1146.           {
  1147.             tmp = set_vectors[length_word_index + i];
  1148. !           set_vectors[length_word_index + i]
  1149. !             = set_vectors[setv_fill_count - i];
  1150.             set_vectors[setv_fill_count - i] = tmp;
  1151.           }
  1152.   
  1153. --- 2874,2881 ----
  1154.              i++)
  1155.           {
  1156.             tmp = set_vectors[length_word_index + i];
  1157. !           set_vectors[length_word_index + i] =
  1158. !             set_vectors[setv_fill_count - i];
  1159.             set_vectors[setv_fill_count - i] = tmp;
  1160.           }
  1161.   
  1162. ***************
  1163. *** 2600,2608 ****
  1164. --- 2886,2896 ----
  1165.       }
  1166.       }
  1167.   
  1168. + #ifdef foobar
  1169.     /* Make sure end of bss is aligned as much as anyone can want.  */
  1170.   
  1171.     bss_size = (bss_size + sizeof(double) - 1) & ~(sizeof(double)-1);
  1172. + #endif
  1173.   
  1174.     if (end_symbol)        /* These are null if -r.  */
  1175.       {
  1176. ***************
  1177. *** 2616,2624 ****
  1178.     if (specified_data_size && specified_data_size > data_size)
  1179.       data_pad = specified_data_size - data_size;
  1180.   
  1181.     if (magic == ZMAGIC)
  1182.       data_pad = ((data_pad + data_size + page_size - 1) & (- page_size))
  1183. !                - data_size;
  1184.   
  1185.     bss_size -= data_pad;
  1186.     if (bss_size < 0) bss_size = 0;
  1187. --- 2904,2916 ----
  1188.     if (specified_data_size && specified_data_size > data_size)
  1189.       data_pad = specified_data_size - data_size;
  1190.   
  1191. + #ifdef SMAGIC
  1192. +   if (magic == SMAGIC || magic == ZMAGIC)
  1193. + #else
  1194.     if (magic == ZMAGIC)
  1195. + #endif
  1196.       data_pad = ((data_pad + data_size + page_size - 1) & (- page_size))
  1197. !     - data_size;
  1198.   
  1199.     bss_size -= data_pad;
  1200.     if (bss_size < 0) bss_size = 0;
  1201. ***************
  1202. *** 2788,2794 ****
  1203.   {
  1204.     int line;
  1205.     char *filename;
  1206. !   struct nlist *sym;
  1207.   };
  1208.   
  1209.   void qsort ();
  1210. --- 3080,3086 ----
  1211.   {
  1212.     int line;
  1213.     char *filename;
  1214. !   struct nlist *Sym;
  1215.   };
  1216.   
  1217.   void qsort ();
  1218. ***************
  1219. *** 2824,2850 ****
  1220.       *next = state_pointer + 1,
  1221.       /* Used to store source file */
  1222.       *source = state_pointer + 2;
  1223. !   struct file_entry *entry = (struct file_entry *) source->sym;
  1224.   
  1225. !   current->sym = next->sym;
  1226.     current->line = next->line;
  1227.     current->filename = next->filename;
  1228.   
  1229. !   while (++(next->sym) < (entry->symbols
  1230.                 + entry->header.a_syms/sizeof (struct nlist)))
  1231.       {
  1232.         /* n_type is a char, and N_SOL, N_EINCL and N_BINCL are > 0x80, so
  1233.          * may look negative...therefore, must mask to low bits
  1234.          */
  1235. !       switch (next->sym->n_type & 0xff) 
  1236.       {
  1237.       case N_SLINE:
  1238.         if (use_data_symbols) continue;
  1239. !       next->line = next->sym->n_desc;
  1240.         return 1;
  1241.       case N_DSLINE:
  1242.         if (!use_data_symbols) continue;
  1243. !       next->line = next->sym->n_desc;
  1244.         return 1;
  1245.   #ifdef HAVE_SUN_STABS
  1246.       case N_EINCL:
  1247. --- 3116,3142 ----
  1248.       *next = state_pointer + 1,
  1249.       /* Used to store source file */
  1250.       *source = state_pointer + 2;
  1251. !   struct file_entry *entry = (struct file_entry *) source->Sym;
  1252.   
  1253. !   current->Sym = next->Sym;
  1254.     current->line = next->line;
  1255.     current->filename = next->filename;
  1256.   
  1257. !   while (++(next->Sym) < (entry->symbols
  1258.                 + entry->header.a_syms/sizeof (struct nlist)))
  1259.       {
  1260.         /* n_type is a char, and N_SOL, N_EINCL and N_BINCL are > 0x80, so
  1261.          * may look negative...therefore, must mask to low bits
  1262.          */
  1263. !       switch (next->Sym->n_type & 0xff) 
  1264.       {
  1265.       case N_SLINE:
  1266.         if (use_data_symbols) continue;
  1267. !       next->line = next->Sym->n_desc;
  1268.         return 1;
  1269.       case N_DSLINE:
  1270.         if (!use_data_symbols) continue;
  1271. !       next->line = next->Sym->n_desc;
  1272.         return 1;
  1273.   #ifdef HAVE_SUN_STABS
  1274.       case N_EINCL:
  1275. ***************
  1276. *** 2852,2870 ****
  1277.         continue;
  1278.   #endif
  1279.       case N_SO:
  1280. !       source->filename = next->sym->n_un.n_strx + entry->strings;
  1281.         source->line++;
  1282.   #ifdef HAVE_SUN_STABS
  1283.       case N_BINCL:
  1284.   #endif
  1285.       case N_SOL:
  1286. !       next->filename
  1287. !         = next->sym->n_un.n_strx + entry->strings;
  1288.       default:
  1289.         continue;
  1290.       }
  1291.       }
  1292. !   next->sym = (struct nlist *) 0;
  1293.     return 0;
  1294.   }
  1295.   
  1296. --- 3144,3162 ----
  1297.         continue;
  1298.   #endif
  1299.       case N_SO:
  1300. !       source->filename = next->Sym->n_un.n_strx + entry->strings;
  1301.         source->line++;
  1302.   #ifdef HAVE_SUN_STABS
  1303.       case N_BINCL:
  1304.   #endif
  1305.       case N_SOL:
  1306. !       next->filename =
  1307. !         next->Sym->n_un.n_strx + entry->strings;
  1308.       default:
  1309.         continue;
  1310.       }
  1311.       }
  1312. !   next->Sym = (struct nlist *) 0;
  1313.     return 0;
  1314.   }
  1315.   
  1316. ***************
  1317. *** 2879,2887 ****
  1318.        struct file_entry *entry;
  1319.   {
  1320.     struct line_debug_entry
  1321. !     *state_pointer
  1322. !       = (struct line_debug_entry *)
  1323. !     xmalloc (3 * sizeof (struct line_debug_entry));
  1324.     register struct line_debug_entry
  1325.       *current = state_pointer,
  1326.       *next = state_pointer + 1,
  1327. --- 3171,3179 ----
  1328.        struct file_entry *entry;
  1329.   {
  1330.     struct line_debug_entry
  1331. !     *state_pointer =
  1332. !         (struct line_debug_entry *)
  1333. !         xmalloc (3 * sizeof (struct line_debug_entry));
  1334.     register struct line_debug_entry
  1335.       *current = state_pointer,
  1336.       *next = state_pointer + 1,
  1337. ***************
  1338. *** 2902,2908 ****
  1339.         /* I believe this translates to "We lose" */
  1340.         current->filename = next->filename = entry->filename;
  1341.         current->line = next->line = -1;
  1342. !       current->sym = next->sym = (struct nlist *) 0;
  1343.         return state_pointer;
  1344.       }
  1345.   
  1346. --- 3194,3200 ----
  1347.         /* I believe this translates to "We lose" */
  1348.         current->filename = next->filename = entry->filename;
  1349.         current->line = next->line = -1;
  1350. !       current->Sym = next->Sym = (struct nlist *) 0;
  1351.         return state_pointer;
  1352.       }
  1353.   
  1354. ***************
  1355. *** 2909,2920 ****
  1356.     next->line = source->line = 0;
  1357.     next->filename = source->filename
  1358.       = (tmp->n_un.n_strx + entry->strings);
  1359. !   source->sym = (struct nlist *) entry;
  1360. !   next->sym = tmp;
  1361.   
  1362.     next_debug_entry (use_data_symbols, state_pointer); /* To setup next */
  1363.   
  1364. !   if (!next->sym)        /* No line numbers for this section; */
  1365.                   /* setup output results as appropriate */
  1366.       {
  1367.         if (source->line)
  1368. --- 3201,3212 ----
  1369.     next->line = source->line = 0;
  1370.     next->filename = source->filename
  1371.       = (tmp->n_un.n_strx + entry->strings);
  1372. !   source->Sym = (struct nlist *) entry;
  1373. !   next->Sym = tmp;
  1374.   
  1375.     next_debug_entry (use_data_symbols, state_pointer); /* To setup next */
  1376.   
  1377. !   if (!next->Sym)        /* No line numbers for this section; */
  1378.                   /* setup output results as appropriate */
  1379.       {
  1380.         if (source->line)
  1381. ***************
  1382. *** 2954,2970 ****
  1383.   
  1384.     int use_data_symbols;
  1385.   
  1386. !   if (next->sym)
  1387. !     use_data_symbols = (next->sym->n_type & N_TYPE) == N_DATA;
  1388.     else
  1389.       return current->line;
  1390.   
  1391.     /* Go back to the beginning if we've already passed it.  */
  1392. !   if (current->sym->n_value > address)
  1393.       {
  1394.         tmp_pointer = init_debug_scan (use_data_symbols,
  1395.                        (struct file_entry *)
  1396. !                      ((state_pointer + 2)->sym));
  1397.         state_pointer[0] = tmp_pointer[0];
  1398.         state_pointer[1] = tmp_pointer[1];
  1399.         state_pointer[2] = tmp_pointer[2];
  1400. --- 3246,3262 ----
  1401.   
  1402.     int use_data_symbols;
  1403.   
  1404. !   if (next->Sym)
  1405. !     use_data_symbols = (next->Sym->n_type & N_TYPE) == N_DATA;
  1406.     else
  1407.       return current->line;
  1408.   
  1409.     /* Go back to the beginning if we've already passed it.  */
  1410. !   if (current->Sym->n_value > address)
  1411.       {
  1412.         tmp_pointer = init_debug_scan (use_data_symbols,
  1413.                        (struct file_entry *)
  1414. !                      ((state_pointer + 2)->Sym));
  1415.         state_pointer[0] = tmp_pointer[0];
  1416.         state_pointer[1] = tmp_pointer[1];
  1417.         state_pointer[2] = tmp_pointer[2];
  1418. ***************
  1419. *** 2972,2982 ****
  1420.       }
  1421.   
  1422.     /* If we're still in a bad way, return -1, meaning invalid line.  */
  1423. !   if (current->sym->n_value > address)
  1424.       return -1;
  1425.   
  1426. !   while (next->sym
  1427. !      && next->sym->n_value <= address
  1428.        && next_debug_entry (use_data_symbols, state_pointer))
  1429.       ;
  1430.     return current->line;
  1431. --- 3264,3274 ----
  1432.       }
  1433.   
  1434.     /* If we're still in a bad way, return -1, meaning invalid line.  */
  1435. !   if (current->Sym->n_value > address)
  1436.       return -1;
  1437.   
  1438. !   while (next->Sym
  1439. !      && next->Sym->n_value <= address
  1440.        && next_debug_entry (use_data_symbols, state_pointer))
  1441.       ;
  1442.     return current->line;
  1443. ***************
  1444. *** 3006,3023 ****
  1445.     struct relocation_info
  1446.       *reloc_start = data_segment ? entry->datarel : entry->textrel,
  1447.       *reloc;
  1448. !   int reloc_size
  1449. !     = ((data_segment ? entry->header.a_drsize : entry->header.a_trsize)
  1450. !        / sizeof (struct relocation_info));
  1451. !   int start_of_segment
  1452. !     = (data_segment ? entry->data_start_address : entry->text_start_address);
  1453.     struct nlist *start_of_syms = entry->symbols;
  1454. !   struct line_debug_entry *state_pointer
  1455. !     = init_debug_scan (data_segment != 0, entry);
  1456.     register struct line_debug_entry
  1457. !     *current = state_pointer,
  1458. !     *next = state_pointer + 1,
  1459. !     *source = state_pointer + 2;
  1460.     /* Assigned to generally static values; should not be written into.  */
  1461.     char *errfmt;
  1462.     /* Assigned to alloca'd values cand copied into; should be freed
  1463. --- 3298,3313 ----
  1464.     struct relocation_info
  1465.       *reloc_start = data_segment ? entry->datarel : entry->textrel,
  1466.       *reloc;
  1467. !   int reloc_size =
  1468. !     (data_segment ? entry->header.a_drsize : entry->header.a_trsize)
  1469. !        / sizeof (struct relocation_info);
  1470. !   int start_of_segment =
  1471. !     (data_segment ? entry->data_start_address : entry->text_start_address);
  1472.     struct nlist *start_of_syms = entry->symbols;
  1473. !   struct line_debug_entry *state_pointer =
  1474. !     init_debug_scan (data_segment != 0, entry);
  1475.     register struct line_debug_entry
  1476. !     *current = state_pointer;
  1477.     /* Assigned to generally static values; should not be written into.  */
  1478.     char *errfmt;
  1479.     /* Assigned to alloca'd values cand copied into; should be freed
  1480. ***************
  1481. *** 3095,3102 ****
  1482.         /* If errfmt == 0, errmsg has already been defined.  */
  1483.         if (errfmt != 0)
  1484.       {
  1485. !       errmsg = (char *) xmalloc (strlen (errfmt) + strlen (g->name) + 1);
  1486. !       sprintf (errmsg, errfmt, g->name, data_segment ? "data" : "text");
  1487.       }
  1488.   
  1489.         address_to_line (RELOC_ADDRESS (reloc) + start_of_segment,
  1490. --- 3385,3398 ----
  1491.         /* If errfmt == 0, errmsg has already been defined.  */
  1492.         if (errfmt != 0)
  1493.       {
  1494. !       char *nm;
  1495. ! 
  1496. !       if (demangler == NULL || (nm = (*demangler)(g->name)) == NULL)
  1497. !         nm = g->name;
  1498. !       errmsg = (char *) xmalloc (strlen (errfmt) + strlen (nm) + 1);
  1499. !       sprintf (errmsg, errfmt, nm, data_segment ? "data" : "text");
  1500. !       if (nm != g->name)
  1501. !         free (nm);
  1502.       }
  1503.   
  1504.         address_to_line (RELOC_ADDRESS (reloc) + start_of_segment,
  1505. ***************
  1506. *** 3125,3132 ****
  1507.        FILE *outfile;
  1508.   {
  1509.     int number_of_syms = entry->header.a_syms / sizeof (struct nlist);
  1510. !   unsigned char *nlist_bitvector
  1511. !     = (unsigned char *) alloca ((number_of_syms >> 3) + 1);
  1512.     struct line_debug_entry *text_scan, *data_scan;
  1513.     int i;
  1514.     char *errfmt, *file_name;
  1515. --- 3421,3428 ----
  1516.        FILE *outfile;
  1517.   {
  1518.     int number_of_syms = entry->header.a_syms / sizeof (struct nlist);
  1519. !   unsigned char *nlist_bitvector =
  1520. !     (unsigned char *) alloca ((number_of_syms >> 3) + 1);
  1521.     struct line_debug_entry *text_scan, *data_scan;
  1522.     int i;
  1523.     char *errfmt, *file_name;
  1524. ***************
  1525. *** 3204,3210 ****
  1526.       {
  1527.         if (g->undef_refs >= MAX_UREFS_PRINTED)
  1528.           continue;
  1529. !       
  1530.         if (++(g->undef_refs) == MAX_UREFS_PRINTED)
  1531.           errfmt = "More undefined \"%s\" refs follow";
  1532.         else
  1533. --- 3500,3506 ----
  1534.       {
  1535.         if (g->undef_refs >= MAX_UREFS_PRINTED)
  1536.           continue;
  1537. ! 
  1538.         if (++(g->undef_refs) == MAX_UREFS_PRINTED)
  1539.           errfmt = "More undefined \"%s\" refs follow";
  1540.         else
  1541. ***************
  1542. *** 3227,3233 ****
  1543.       }
  1544.         else
  1545.       continue;
  1546. !       
  1547.         if (line_number == -1)
  1548.       fprintf (outfile, "%s: ", entry->filename);
  1549.         else
  1550. --- 3523,3529 ----
  1551.       }
  1552.         else
  1553.       continue;
  1554. ! 
  1555.         if (line_number == -1)
  1556.       fprintf (outfile, "%s: ", entry->filename);
  1557.         else
  1558. ***************
  1559. *** 3234,3242 ****
  1560.       fprintf (outfile, "%s:%d: ", file_name, line_number);
  1561.   
  1562.         if (dont_allow_symbol_name)
  1563. !     fprintf (outfile, "%s", errfmt);
  1564.         else
  1565. !     fprintf (outfile, errfmt, g->name);
  1566.   
  1567.         fputc ('\n', outfile);
  1568.       }
  1569. --- 3530,3546 ----
  1570.       fprintf (outfile, "%s:%d: ", file_name, line_number);
  1571.   
  1572.         if (dont_allow_symbol_name)
  1573. !       fprintf (outfile, "%s", errfmt);
  1574.         else
  1575. !       {
  1576. !     char *nm;
  1577. !     if (demangler != NULL && (nm = (*demangler)(g->name)) != NULL)
  1578. !       {
  1579. !         fprintf (outfile, errfmt, nm);
  1580. !         free (nm);
  1581. !       } else
  1582. !         fprintf (outfile, errfmt, g->name);
  1583. !       }
  1584.   
  1585.         fputc ('\n', outfile);
  1586.       }
  1587. ***************
  1588. *** 3261,3267 ****
  1589.       return;
  1590.   
  1591.     each_file (do_file_warnings, outfile);
  1592. ! 
  1593.     if (list_unresolved_refs || list_multiple_defs)
  1594.       make_executable = 0;
  1595.   }
  1596. --- 3565,3573 ----
  1597.       return;
  1598.   
  1599.     each_file (do_file_warnings, outfile);
  1600. !   if (trace_files)
  1601. !       printf("undefined_global_sym_count= %d, multiple_def_count= %d\n",
  1602. !          undefined_global_sym_count, multiple_def_count);
  1603.     if (list_unresolved_refs || list_multiple_defs)
  1604.       make_executable = 0;
  1605.   }
  1606. ***************
  1607. *** 3314,3321 ****
  1608.   {
  1609.     N_SET_MAGIC (outheader, magic);
  1610.     outheader.a_text = text_size;
  1611. ! #ifdef sequent
  1612.     outheader.a_text += N_ADDRADJ (outheader);
  1613.   #endif
  1614.     outheader.a_data = data_size;
  1615.     outheader.a_bss = bss_size;
  1616. --- 3620,3631 ----
  1617.   {
  1618.     N_SET_MAGIC (outheader, magic);
  1619.     outheader.a_text = text_size;
  1620. !   if (T_flag_specified)
  1621. !       outheader.a_text += text_start;
  1622. ! #if TARGET_MACHINE==TARGET_SEQUENT
  1623.     outheader.a_text += N_ADDRADJ (outheader);
  1624. +   if (entry_symbol == 0)
  1625. +       entry_symbol = getsym("start");
  1626.   #endif
  1627.     outheader.a_data = data_size;
  1628.     outheader.a_bss = bss_size;
  1629. ***************
  1630. *** 3383,3389 ****
  1631. --- 3693,3717 ----
  1632.         coffheader.data_start = dp->s_vaddr;
  1633.       }
  1634.   #endif
  1635. + #if TARGET==TARGET_SEQUENT
  1636. +     if (SMAGIC == magic) {
  1637. +     char *target_ptr; 
  1638. +     long n; 
  1639.   
  1640. +     outheader.a_gdtbl = gdt_filler; 
  1641. +     if (sizeof(instr) > sizeof(outheader.a_bootstrap)) {
  1642. +         fatal("a_bootstrap too small for code"); 
  1643. +     } 
  1644. +     n = outheader.a_entry; 
  1645. +     target_ptr = &instr[sizeof(instr) - 4];
  1646. +     target_ptr[0] = n & 0xff; 
  1647. +     target_ptr[1] = (n >> 8) & 0xff; 
  1648. +     target_ptr[2] = (n >> 16) & 0xff; 
  1649. +     target_ptr[3] = (n >> 24) & 0xff; 
  1650. +     bcopy(instr, (char *)outheader.a_bootstrap, sizeof(instr)); 
  1651. +     }
  1652. + #endif
  1653. + 
  1654.   #ifdef INITIALIZE_HEADER
  1655.     INITIALIZE_HEADER;
  1656.   #endif
  1657. ***************
  1658. *** 3423,3429 ****
  1659. --- 3751,3763 ----
  1660.     if (need_coff_header)
  1661.       mywrite (&coffheader, sizeof coffheader, 1, outdesc);
  1662.   #endif
  1663. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1664. +   fix_exec_header_byte_order(&outheader);
  1665. + #endif
  1666.     mywrite (&outheader, sizeof (struct exec), 1, outdesc);
  1667. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1668. +   fix_exec_header_byte_order(&outheader);
  1669. + #endif
  1670.   
  1671.     /* Output whatever padding is required in the executable file
  1672.        between the header and the start of the text.  */
  1673. ***************
  1674. *** 3431,3436 ****
  1675. --- 3765,3775 ----
  1676.   #ifndef COFF_ENCAPSULATE
  1677.     padfile (N_TXTOFF (outheader) - sizeof outheader, outdesc);
  1678.   #endif
  1679. + 
  1680. + 
  1681. +   if (T_flag_specified)
  1682. +       padfile (text_start - sizeof(struct exec), outdesc);
  1683. + 
  1684.   }
  1685.   
  1686.   /* Relocate the text segment of each input file
  1687. ***************
  1688. *** 3489,3494 ****
  1689. --- 3828,3837 ----
  1690.         fprintf (stderr, "Return from read: %d\n", read_return);
  1691.         fatal_with_file ("premature eof in text relocation of ", entry);
  1692.       }
  1693. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1694. +       target_to_host_reloc_byte_order(reloc,
  1695. +     entry->header.a_trsize/sizeof(*reloc));
  1696. + #endif
  1697.         entry->textrel = reloc;
  1698.       }
  1699.   
  1700. ***************
  1701. *** 3502,3507 ****
  1702. --- 3845,3854 ----
  1703.            L_SET);
  1704.         if (entry->header.a_drsize != read (desc, reloc, entry->header.a_drsize))
  1705.       fatal_with_file ("premature eof in data relocation of ", entry);
  1706. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1707. +       target_to_host_reloc_byte_order(reloc,
  1708. +     entry->header.a_drsize/sizeof(*reloc));
  1709. + #endif
  1710.         entry->datarel = reloc;
  1711.       }
  1712.   }
  1713. ***************
  1714. *** 3538,3546 ****
  1715. --- 3885,3902 ----
  1716.     else
  1717.       {
  1718.         reloc = (struct relocation_info *) alloca (entry->header.a_trsize);
  1719. +       if (trace_files)
  1720. +           printf("lseek to 0x%x (t_o= 0x%x, a_t= 0x%x, a_d= 0x%x)\n",
  1721. +              text_offset(entry) + entry->header.a_text +
  1722. +              entry->header.a_data, text_offset(entry),
  1723. +              entry->header.a_text, entry->header.a_data);
  1724.         lseek (desc, text_offset (entry) + entry->header.a_text + entry->header.a_data, 0);
  1725.         if (entry->header.a_trsize != read (desc, reloc, entry->header.a_trsize))
  1726.       fatal_with_file ("premature eof in text relocation of ", entry);
  1727. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1728. +       target_to_host_reloc_byte_order(reloc,
  1729. +       entry->header.a_trsize/sizeof(*reloc));
  1730. + #endif
  1731.       }
  1732.   
  1733.     /* Read the text section into core.  */
  1734. ***************
  1735. *** 3575,3580 ****
  1736. --- 3931,3945 ----
  1737.     /* Write out the set element vectors.  See digest symbols for
  1738.        description of length of the set vector section.  */
  1739.   
  1740. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1741. +   {
  1742. +     int i;
  1743. +     for (i = 0; i < 2 * set_symbol_count + set_vector_count; ++i) {
  1744. +     fix_byte_order(&set_vectors[i], sizeof(*set_vectors));
  1745. +     }
  1746. +   }
  1747. + #endif
  1748. + 
  1749.     if (set_vector_count)
  1750.       mywrite (set_vectors, 2 * set_symbol_count + set_vector_count,
  1751.            sizeof (unsigned long), outdesc);
  1752. ***************
  1753. *** 3619,3624 ****
  1754. --- 3984,3993 ----
  1755.            0);
  1756.         if (entry->header.a_drsize != read (desc, reloc, entry->header.a_drsize))
  1757.       fatal_with_file ("premature eof in data relocation of ", entry);
  1758. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1759. +       target_to_host_reloc_byte_order(reloc,
  1760. +       entry->header.a_drsize/sizeof(*reloc));
  1761. + #endif
  1762.       }
  1763.   
  1764.     lseek (desc, text_offset (entry) + entry->header.a_text, 0);
  1765. ***************
  1766. *** 3662,3667 ****
  1767. --- 4031,4037 ----
  1768.         register int relocation = 0;
  1769.         register int addr = RELOC_ADDRESS(p);
  1770.         register unsigned int mask = 0;
  1771. +       register unsigned int x;
  1772.   
  1773.         if (addr >= data_size)
  1774.       fatal_with_file ("relocation address out of range in ", entry);
  1775. ***************
  1776. *** 3719,3727 ****
  1777.       default:
  1778.         fatal_with_file ("nonexternal relocation code invalid in ", entry);
  1779.       }
  1780. ! 
  1781.         if (RELOC_PCREL_P(p))
  1782.       relocation -= pc_relocation;
  1783.   
  1784.   #ifdef RELOC_ADD_EXTRA
  1785.         relocation += RELOC_ADD_EXTRA(p);
  1786. --- 4089,4098 ----
  1787.       default:
  1788.         fatal_with_file ("nonexternal relocation code invalid in ", entry);
  1789.       }
  1790. ! #if 0
  1791.         if (RELOC_PCREL_P(p))
  1792.       relocation -= pc_relocation;
  1793. + #endif
  1794.   
  1795.   #ifdef RELOC_ADD_EXTRA
  1796.         relocation += RELOC_ADD_EXTRA(p);
  1797. ***************
  1798. *** 3737,3746 ****
  1799.             else
  1800.           RELOC_ADD_EXTRA (p) -= pc_relocation;
  1801.           }
  1802. ! #if 0
  1803.         if (! RELOC_PCREL_P (p))
  1804.           {
  1805. !           if ((int)p->r_type <= RELOC_32
  1806.             || RELOC_EXTERN_P (p) == 0)
  1807.           RELOC_ADD_EXTRA (p) = relocation;
  1808.           }
  1809. --- 4108,4117 ----
  1810.             else
  1811.           RELOC_ADD_EXTRA (p) -= pc_relocation;
  1812.           }
  1813. ! #if 1
  1814.         if (! RELOC_PCREL_P (p))
  1815.           {
  1816. !           if ((int)p->r_type <= (int) RELOC_32
  1817.             || RELOC_EXTERN_P (p) == 0)
  1818.           RELOC_ADD_EXTRA (p) = relocation;
  1819.           }
  1820. ***************
  1821. *** 3750,3755 ****
  1822. --- 4121,4130 ----
  1823.         continue;
  1824.       }
  1825.   #endif
  1826. + #if 1    
  1827. +        if (RELOC_PCREL_P(p))
  1828. +        relocation -= pc_relocation;
  1829. + #endif
  1830.   
  1831.         relocation >>= RELOC_VALUE_RIGHTSHIFT(p);
  1832.   
  1833. ***************
  1834. *** 3774,3794 ****
  1835.         break;
  1836.   
  1837.       case 1:
  1838.         if (RELOC_MEMORY_SUB_P(p))
  1839. !         relocation -= mask & *(short *) (data + addr);
  1840.         else if (RELOC_MEMORY_ADD_P(p))
  1841. !         relocation += mask & *(short *) (data + addr);
  1842. !       *(short *) (data + addr) &= ~mask;
  1843. !       *(short *) (data + addr) |= relocation;
  1844.         break;
  1845.   
  1846.       case 2:
  1847. !       if (RELOC_MEMORY_SUB_P(p))
  1848. !         relocation -= mask & *(long *) (data + addr);
  1849.         else if (RELOC_MEMORY_ADD_P(p))
  1850. !         relocation += mask & *(long *) (data + addr);
  1851. !       *(long *) (data + addr) &= ~mask;
  1852. !       *(long *) (data + addr) |= relocation;
  1853.         break;
  1854.   
  1855.       default:
  1856. --- 4149,4209 ----
  1857.         break;
  1858.   
  1859.       case 1:
  1860. + #if TARGET_BYTE_ORDER==BIG_ENDIAN
  1861. +       x = ((unsigned char *) (data + addr))[1]
  1862. +        | (((unsigned char *) (data + addr))[0] << 8);
  1863. + #endif
  1864. + #if TARGET_BYTE_ORDER==LITTLE_ENDIAN
  1865. +       x = ((unsigned char *) (data + addr))[0]
  1866. +        | (((unsigned char *) (data + addr))[1] << 8);
  1867. + #endif
  1868.         if (RELOC_MEMORY_SUB_P(p))
  1869. !         relocation -= mask & x;
  1870.         else if (RELOC_MEMORY_ADD_P(p))
  1871. !         relocation += mask & x;
  1872. !       x &= ~mask;
  1873. !       x |= relocation;
  1874. ! #if TARGET_BYTE_ORDER==BIG_ENDIAN
  1875. !       ((unsigned char *) (data + addr))[1] = x;
  1876. !       ((unsigned char *) (data + addr))[0] = x >> 8;
  1877. ! #endif
  1878. ! #if TARGET_BYTE_ORDER==LITTLE_ENDIAN
  1879. !       ((unsigned char *) (data + addr))[0] = x;
  1880. !       ((unsigned char *) (data + addr))[1] = x >> 8;
  1881. ! #endif
  1882.         break;
  1883.   
  1884.       case 2:
  1885. ! #if TARGET_BYTE_ORDER==BIG_ENDIAN
  1886. !       x = ((unsigned char *) (data + addr))[3]
  1887. !        | (((unsigned char *) (data + addr))[2] << 8)
  1888. !        | (((unsigned char *) (data + addr))[1] << 16)
  1889. !        | (((unsigned char *) (data + addr))[0] << 24);
  1890. ! #endif
  1891. ! #if TARGET_BYTE_ORDER==LITTLE_ENDIAN
  1892. !       x = ((unsigned char *) (data + addr))[0]
  1893. !        | (((unsigned char *) (data + addr))[1] << 8)
  1894. !        | (((unsigned char *) (data + addr))[2] << 16)
  1895. !        | (((unsigned char *) (data + addr))[3] << 24);
  1896. ! #endif
  1897. !           if (RELOC_MEMORY_SUB_P(p))
  1898. !         relocation -= mask & x;
  1899.         else if (RELOC_MEMORY_ADD_P(p))
  1900. !         relocation += mask & x;
  1901. !       x &= ~mask;
  1902. !       x |= relocation;
  1903. ! #if TARGET_BYTE_ORDER==BIG_ENDIAN
  1904. !       ((unsigned char *) (data + addr))[3] = x;
  1905. !       ((unsigned char *) (data + addr))[2] = x >> 8;
  1906. !       ((unsigned char *) (data + addr))[1] = x >> 16;
  1907. !       ((unsigned char *) (data + addr))[0] = x >> 24;
  1908. ! #endif
  1909. ! #if TARGET_BYTE_ORDER==LITTLE_ENDIAN
  1910. !       ((unsigned char *) (data + addr))[0] = x;
  1911. !       ((unsigned char *) (data + addr))[1] = x >> 8;
  1912. !       ((unsigned char *) (data + addr))[2] = x >> 16;
  1913. !       ((unsigned char *) (data + addr))[3] = x >> 24;
  1914. ! #endif
  1915.         break;
  1916.   
  1917.       default:
  1918. ***************
  1919. *** 3903,3908 ****
  1920. --- 4318,4327 ----
  1921.       }
  1922.         p++;
  1923.       }
  1924. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1925. +     host_to_target_reloc_byte_order((struct relocation_info *) entry->textrel,
  1926. +     entry->header.a_trsize/sizeof(struct relocation_info));
  1927. + #endif
  1928.     mywrite (entry->textrel, 1, entry->header.a_trsize, outdesc);
  1929.   }
  1930.   
  1931. ***************
  1932. *** 3962,3967 ****
  1933. --- 4381,4390 ----
  1934.       }
  1935.         p++;
  1936.       }
  1937. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1938. +     host_to_target_reloc_byte_order((struct relocation_info *) entry->datarel,
  1939. +     entry->header.a_drsize/sizeof(struct relocation_info));
  1940. + #endif
  1941.     mywrite (entry->datarel, 1, entry->header.a_drsize, outdesc);
  1942.   }
  1943.   
  1944. ***************
  1945. *** 4169,4174 ****
  1946. --- 4592,4609 ----
  1947.     /* Output the buffer full of `struct nlist's.  */
  1948.   
  1949.     lseek (outdesc, symbol_table_offset + symbol_table_len, 0);
  1950. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1951. +   {
  1952. +     int i;
  1953. + 
  1954. +     for (i = 0; i < bufp - buf; ++i)
  1955. +       {
  1956. +         fix_byte_order(&buf[i].n_un.n_name, sizeof(buf->n_un.n_name));
  1957. +     fix_byte_order(&buf[i].n_desc, sizeof(buf->n_desc));
  1958. +     fix_byte_order(&buf[i].n_value, sizeof(buf->n_value));
  1959. +       }
  1960. +   }
  1961. + #endif
  1962.     mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc);
  1963.     symbol_table_len += sizeof (struct nlist) * (bufp - buf);
  1964.   
  1965. ***************
  1966. *** 4181,4186 ****
  1967. --- 4616,4625 ----
  1968.     /* Now the total string table size is known, so write it.
  1969.        We are already positioned at the right place in the file.  */
  1970.   
  1971. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1972. +   fix_byte_order(&strtab_size, sizeof(strtab_size));
  1973. + #endif
  1974. + 
  1975.     mywrite (&strtab_size, sizeof (int), 1, outdesc);  /* we're at right place */
  1976.   
  1977.     /* Write the strings for the global symbols.  */
  1978. ***************
  1979. *** 4224,4230 ****
  1980. --- 4663,4673 ----
  1981.       {
  1982.         struct nlist nl;
  1983.   
  1984. + #if TARGET==TARGET_SEQUENT      
  1985. +       nl.n_type = N_FN;
  1986. + #else      
  1987.         nl.n_type = N_TEXT;
  1988. + #endif
  1989.         nl.n_un.n_strx = assign_string_table_index (entry->local_sym_name);
  1990.         nl.n_value = entry->text_start_address;
  1991.         nl.n_desc = 0;
  1992. ***************
  1993. *** 4281,4286 ****
  1994. --- 4724,4741 ----
  1995.     /* All the symbols are now in BUF; write them.  */
  1996.   
  1997.     lseek (outdesc, symbol_table_offset + symbol_table_len, 0);
  1998. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  1999. +   {
  2000. +     int i;
  2001. + 
  2002. +     for (i = 0; i < bufp - buf; ++i)
  2003. +       {
  2004. +     fix_byte_order(&buf[i].n_un.n_name, sizeof(buf->n_un.n_name));
  2005. +     fix_byte_order(&buf[i].n_desc, sizeof(buf->n_desc));
  2006. +     fix_byte_order(&buf[i].n_value, sizeof(buf->n_value));
  2007. +       }
  2008. +   }
  2009. + #endif
  2010.     mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc);
  2011.     symbol_table_len += sizeof (struct nlist) * (bufp - buf);
  2012.   
  2013. ***************
  2014. *** 4322,4327 ****
  2015. --- 4777,4786 ----
  2016.     if (sizeof root != read (indesc, &root, sizeof root))
  2017.       fatal_with_file ("premature end of file in symbol segment of ", entry);
  2018.   
  2019. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  2020. +   fix_symbol_root_byte_order(&root);
  2021. + #endif
  2022. + 
  2023.     /* Store some relocation info into the root.  */
  2024.   
  2025.     root.ldsymoff = entry->local_syms_offset;
  2026. ***************
  2027. *** 4334,4339 ****
  2028. --- 4793,4801 ----
  2029.   
  2030.     /* Write the modified root into the output file.  */
  2031.   
  2032. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  2033. +   fix_symbol_root_byte_order(&root);
  2034. + #endif
  2035.     mywrite (&root, sizeof root, 1, outdesc);
  2036.   
  2037.     /* Copy the rest of the symbol segment unchanged.  */
  2038. ***************
  2039. *** 4385,4391 ****
  2040.     end_symbol = getsym ("end");
  2041.   #endif
  2042.   
  2043. ! #ifdef sun
  2044.     {
  2045.       symbol *dynamic_symbol = getsym ("__DYNAMIC");
  2046.       dynamic_symbol->defined = N_ABS | N_EXT;
  2047. --- 4847,4853 ----
  2048.     end_symbol = getsym ("end");
  2049.   #endif
  2050.   
  2051. ! #if TARGET_MACHINE==TARGET_SUN4 || TARGET_MACHINE==TARGET_SUN3 || TARGET_MACHINE==TARGET_SUN2
  2052.     {
  2053.       symbol *dynamic_symbol = getsym ("__DYNAMIC");
  2054.       dynamic_symbol->defined = N_ABS | N_EXT;
  2055. ***************
  2056. *** 4393,4399 ****
  2057.       dynamic_symbol->value = 0;
  2058.     }
  2059.   #endif
  2060. ! #ifdef sequent
  2061.     {
  2062.       symbol *_387_flt_symbol = getsym ("_387_flt");
  2063.       _387_flt_symbol->defined = N_ABS | N_EXT;
  2064. --- 4855,4861 ----
  2065.       dynamic_symbol->value = 0;
  2066.     }
  2067.   #endif
  2068. ! #if TARGET_MACHINE==TARGET_SEQUENT
  2069.     {
  2070.       symbol *_387_flt_symbol = getsym ("_387_flt");
  2071.       _387_flt_symbol->defined = N_ABS | N_EXT;
  2072. ***************
  2073. *** 4691,4693 ****
  2074. --- 5153,5323 ----
  2075.   }
  2076.   
  2077.   #endif
  2078. + 
  2079. + 
  2080. + #if HOST_BYTE_ORDER != TARGET_BYTE_ORDER
  2081. + 
  2082. + static void
  2083. + fix_byte_order(p, n)
  2084. +     char *p;
  2085. +     int n;
  2086. + {
  2087. +     char t;
  2088. + 
  2089. +     switch (n) {
  2090. + 
  2091. +     case 1:
  2092. +     return;
  2093. + 
  2094. +     case 2:
  2095. +     t = p[0];
  2096. +     p[0] = p[1];
  2097. +     p[1] = t;
  2098. +     return;
  2099. + 
  2100. +     case 4:
  2101. +     t = p[0];
  2102. +     p[0] = p[3];
  2103. +     p[3] = t;
  2104. +     t = p[1];
  2105. +     p[1] = p[2];
  2106. +     p[2] = t;
  2107. +     return;
  2108. + 
  2109. +     default:
  2110. +     fatal("Internal Error in fix_byte_order, n = %d\n", 0);
  2111. +     }
  2112. + }
  2113. + 
  2114. + static void
  2115. + fix_exec_header_byte_order(execP)
  2116. +     struct exec *execP;
  2117. + {
  2118. + 
  2119. + #if TARGET_MACHINE==TARGET_SUN4
  2120. +     if (N_BADMAG(*execP)) {
  2121. +     u_char c = * (u_char *) execP;
  2122. +     execP->a_dynamic = c & 1;
  2123. +     execP->a_toolversion = c >> 1;
  2124. +     } else {
  2125. +     u_char c = execP->a_toolversion | (execP->a_dynamic << 7);
  2126. +     * (u_char *) execP = c;
  2127. +     }
  2128. + #elif TARGET_MACHINE!=TARGET_SEQUENT
  2129. +     fix_byte_order(&execP->a_machtype, sizeof(execP->a_machtype));
  2130. + #endif
  2131. +     fix_byte_order(&execP->a_magic,    sizeof(execP->a_magic));
  2132. +     fix_byte_order(&execP->a_text,     sizeof(execP->a_text));
  2133. +     fix_byte_order(&execP->a_data,     sizeof(execP->a_data));
  2134. +     fix_byte_order(&execP->a_bss,      sizeof(execP->a_bss));
  2135. +     fix_byte_order(&execP->a_syms,     sizeof(execP->a_syms));
  2136. +     fix_byte_order(&execP->a_entry,    sizeof(execP->a_entry));
  2137. +     fix_byte_order(&execP->a_trsize,   sizeof(execP->a_trsize));
  2138. +     fix_byte_order(&execP->a_drsize,   sizeof(execP->a_drsize));
  2139. +     return;
  2140. + }
  2141. + 
  2142. + static void
  2143. + fix_symbol_byte_order(p, size)
  2144. +     struct nlist *p;
  2145. +     int size;
  2146. + {
  2147. +     int n;
  2148. + 
  2149. +     for (n = size / sizeof(*p); --n >= 0; ++p) {
  2150. +     fix_byte_order(&p->n_un, sizeof(p->n_un));
  2151. +     fix_byte_order(&p->n_desc, sizeof(p->n_desc));
  2152. +     fix_byte_order(&p->n_value, sizeof(p->n_value));
  2153. +     }
  2154. +     return;
  2155. + }
  2156. + 
  2157. + static void
  2158. + target_to_host_reloc_byte_order(relocP, nrelocs)
  2159. +     struct relocation_info *relocP;
  2160. +     int nrelocs;
  2161. + {
  2162. +     u_char c[4];
  2163. + 
  2164. + #if TARGET_BYTE_ORDER==BIG_ENDIAN && HOST_BYTE_ORDER==LITTLE_ENDIAN
  2165. +     for (; --nrelocs >= 0; ++relocP) {
  2166. +     fix_byte_order(&relocP->r_address, sizeof(relocP->r_address));
  2167. +     c[0] = ((u_char *) relocP)[4];
  2168. +     c[1] = ((u_char *) relocP)[5];
  2169. +     c[2] = ((u_char *) relocP)[6];
  2170. +     c[3] = ((u_char *) relocP)[7];
  2171. +     ((u_long *) relocP)[1] = 0;
  2172. + #if TARGET_MACHINE==TARGET_SUN4
  2173. +     relocP->r_index = (c[0] << 16) | (c[1] << 8) | c[2];
  2174. +     relocP->r_type = (enum reloc_type) (c[3] & 0x1f);
  2175. +     relocP->r_extern = (c[3] & 0x80) >> 7;
  2176. +     fix_byte_order(&relocP->r_addend, sizeof(relocP->r_addend));
  2177. + #else
  2178. +     relocP->r_symbolnum = (c[0] << 16) | (c[1] << 8) | c[2];
  2179. +     relocP->r_pcrel = (c[3] >> 7) & 1;
  2180. +     relocP->r_length = (c[3] >> 5) & 3;
  2181. +     relocP->r_extern = (c[3] >> 4) & 1;
  2182. + #endif
  2183. +     }
  2184. + #endif
  2185. +     return;
  2186. + }
  2187. + 
  2188. + static void
  2189. + host_to_target_reloc_byte_order(relocP, nrelocs)
  2190. +     struct relocation_info *relocP;
  2191. +     int nrelocs;
  2192. + {
  2193. +     u_char c[4];
  2194. + 
  2195. + #if TARGET_BYTE_ORDER==BIG_ENDIAN && HOST_BYTE_ORDER==LITTLE_ENDIAN
  2196. +     for (; --nrelocs >= 0; ++relocP) {
  2197. +     fix_byte_order(&relocP->r_address, sizeof(relocP->r_address));
  2198. + #if TARGET_MACHINE==TARGET_SUN4
  2199. +     c[0] = (relocP->r_index >> 16);
  2200. +     c[1] = (relocP->r_index >> 8);
  2201. +     c[2] = relocP->r_index;
  2202. +     c[3] = (u_char) relocP->r_type | (relocP->r_extern << 7);
  2203. +     fix_byte_order(&relocP->r_addend, sizeof(relocP->r_addend));
  2204. + #else
  2205. +     c[0] = (relocP->r_symbolnum >> 16);
  2206. +     c[1] = (relocP->r_symbolnum >> 8);
  2207. +     c[2] = relocP->r_symbolnum;
  2208. +     c[3] = (relocP->r_pcrel << 7) |
  2209. +         (relocP->r_length << 5) | (relocP->r_extern << 4);
  2210. + #endif
  2211. +     ((u_char *) relocP)[4] = c[0];
  2212. +     ((u_char *) relocP)[5] = c[1];
  2213. +     ((u_char *) relocP)[6] = c[2];
  2214. +     ((u_char *) relocP)[7] = c[3];
  2215. +     }
  2216. + #endif
  2217. +     return;
  2218. + }
  2219. + 
  2220. + static void
  2221. + fix_symbol_root_byte_order(p)
  2222. +     struct symbol_root *p;
  2223. + {
  2224. + 
  2225. +     fix_byte_order(&p->format, sizeof(p->format));
  2226. +     fix_byte_order(&p->length, sizeof(p->length));
  2227. +     fix_byte_order(&p->ldsymoff, sizeof(p->ldsymoff));
  2228. +     fix_byte_order(&p->textrel, sizeof(p->textrel));
  2229. +     fix_byte_order(&p->datarel, sizeof(p->datarel));
  2230. +     fix_byte_order(&p->bssrel, sizeof(p->bssrel));
  2231. +     fix_byte_order(&p->filename, sizeof(p->filename));
  2232. +     fix_byte_order(&p->filedir, sizeof(p->filedir));
  2233. +     fix_byte_order(&p->blockvector, sizeof(p->blockvector));
  2234. +     fix_byte_order(&p->typevector, sizeof(p->typevector));
  2235. +     fix_byte_order(&p->language, sizeof(p->language));
  2236. +     fix_byte_order(&p->version, sizeof(p->version));
  2237. +     fix_byte_order(&p->compilation, sizeof(p->compilation));
  2238. +     fix_byte_order(&p->databeg, sizeof(p->databeg));
  2239. +     fix_byte_order(&p->bssbeg, sizeof(p->bssbeg));
  2240. +     fix_byte_order(&p->sourcevector, sizeof(p->sourcevector));
  2241. +     return;
  2242. + }
  2243. + 
  2244. + #endif
  2245. + 
  2246.